Windows and Tabs are important browser automation concepts in Selenium WebDriver. Modern web applications frequently open pages in new browser tabs or windows when users click links, buttons, reports, help pages, external services, authentication links, documentation, or other resources.
Selenium WebDriver represents browser tabs and windows using unique Window Handles. To automate elements inside another tab or window, Selenium must first switch its control from the current browser context to the required window handle.
For complete Selenium WebDriver training, Java automation, TestNG, framework development, real-time projects, and advanced browser interactions, visit JustAcademy Selenium Training and Register for Selenium Course Demo.
A browser window is a browser context that can contain one or more tabs. A browser tab is another page opened within the browser. From Selenium WebDriver's point of view, both tabs and windows are handled through window handles.
Every browser context controlled by WebDriver has a unique identifier called a Window Handle.
Browser Session
|
|-- Main Tab / Window
| Handle A
|
|-- New Tab
| Handle B
|
|-- New Window
Handle C
When a new tab or window opens, Selenium does not automatically move its focus to the newly opened browser context. The WebDriver session remains focused on the current context until the test explicitly switches to another handle.
For example:
Main Window
|
| Click "Open Report"
v
New Tab Opens
|
| Selenium is still on Main Window
v
Get Window Handles
|
v
Find New Tab Handle
|
v
Switch to New Tab
|
v
Perform Test Actions
A window handle is a unique string identifier used by Selenium WebDriver to identify a particular browser window or tab during a WebDriver session.
The handle of the currently selected browser context can be obtained using:
String currentWindow = driver.getWindowHandle();Window handles are generated dynamically for the browser session, so they should not normally be hard-coded.
The getWindowHandle() method returns the handle of the currently active browser window or tab.
String parentWindow = driver.getWindowHandle();
System.out.println("Current Window: " + parentWindow);
This handle is commonly stored before opening a new tab so that the test can return to the original page later.
The getWindowHandles() method returns the handles of all currently available browser windows and tabs in the WebDriver session.
Set<String> allWindows = driver.getWindowHandles();
System.out.println("Number of Windows: " + allWindows.size());
The return type is Set<String> because each window handle is unique.
| Method | Purpose | Return Type |
|---|---|---|
| getWindowHandle() | Returns the currently active browser context | String |
| getWindowHandles() | Returns all available browser contexts | Set<String> |
The switchTo().window() method is used to switch Selenium's focus from one browser window or tab to another.
driver.switchTo().window(windowHandle);After switching, Selenium commands such as findElement(), getTitle(), getCurrentUrl(), and element interactions operate on the selected browser context.
The browser context that is active before opening another tab or window is commonly called the parent window. The newly opened browser context is commonly called the child window.
Parent Window
|
| Click link
v
Child Window
|
| Perform validation
v
Switch back
|
v
Parent Window
These are useful test-automation terms. Selenium fundamentally identifies the contexts using window handles.
String parentWindow = driver.getWindowHandle();
driver.findElement(By.id("openWindow")).click();
Set<String> allWindows = driver.getWindowHandles();
for (String window : allWindows) {
if (!window.equals(parentWindow)) {
driver.switchTo().window(window);
break;
}
}
import java.util.Set;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class WindowHandlingExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
String parentWindow = driver.getWindowHandle();
driver.findElement(By.id("openWindow")).click();
Set<String> windows = driver.getWindowHandles();
for (String window : windows) {
if (!window.equals(parentWindow)) {
driver.switchTo().window(window);
System.out.println(
"Child Title: " + driver.getTitle());
break;
}
}
driver.switchTo().window(parentWindow);
driver.quit();
}
}
After finishing the work in the child tab or window, switch back using the previously stored parent handle.
driver.switchTo().window(parentWindow);This is one of the most important steps in multi-window automation because Selenium will continue working in whichever browser context is currently selected.
An application may open multiple tabs or windows during a test.
Set<String> allWindows = driver.getWindowHandles();
for (String window : allWindows) {
driver.switchTo().window(window);
System.out.println("Handle: " + window);
System.out.println("Title: " + driver.getTitle());
System.out.println("URL: " + driver.getCurrentUrl());
}
This approach allows the test to inspect every browser context.
When several windows are available, the required window can be identified using its page title.
for (String window : driver.getWindowHandles()) {
driver.switchTo().window(window);
if (driver.getTitle().contains("Reports")) {
System.out.println("Reports window found");
break;
}
}
The current URL can also be used to identify a particular window.
for (String window : driver.getWindowHandles()) {
driver.switchTo().window(window);
if (driver.getCurrentUrl().contains("reports")) {
System.out.println("Reports page found");
break;
}
}
In some applications, the title or URL may not be unique. In such cases, the test can switch through the available windows and check for a page-specific element.
for (String window : driver.getWindowHandles()) {
driver.switchTo().window(window);
if (!driver.findElements(
By.id("reportTable")).isEmpty()) {
System.out.println("Report window found");
break;
}
}
An Iterator can be used to access window handles individually.
Set<String> windows = driver.getWindowHandles();
Iterator<String> iterator = windows.iterator();
String parentWindow = iterator.next();
String childWindow = iterator.next();
driver.switchTo().window(childWindow);
This approach is simple for basic scenarios, but for complex applications it is better to identify windows by meaningful properties such as title or URL rather than assuming a particular order.
Java Streams can also be used to locate a window other than the parent window.
String parentWindow = driver.getWindowHandle();
String childWindow = driver.getWindowHandles()
.stream()
.filter(handle -> !handle.equals(parentWindow))
.findFirst()
.orElseThrow();
driver.switchTo().window(childWindow);
Selenium 4 provides the newWindow() method to create a new browser tab or window.
To create a new tab:
driver.switchTo().newWindow(WindowType.TAB);The WebDriver focus moves to the newly created tab.
To create a new browser window:
driver.switchTo().newWindow(WindowType.WINDOW);This creates a new window and switches the WebDriver focus to it.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WindowType;
import org.openqa.selenium.chrome.ChromeDriver;
public class NewTabExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
String parentWindow = driver.getWindowHandle();
driver.switchTo().newWindow(WindowType.TAB);
driver.get("https://www.selenium.dev");
System.out.println(
"New Tab Title: " + driver.getTitle());
driver.switchTo().window(parentWindow);
System.out.println(
"Parent Title: " + driver.getTitle());
driver.quit();
}
}
driver.get("https://example.com");
String parentWindow = driver.getWindowHandle();
driver.switchTo().newWindow(WindowType.WINDOW);
driver.get("https://www.selenium.dev");
System.out.println(driver.getTitle());
driver.switchTo().window(parentWindow);
| Feature | Browser Tab | Browser Window |
|---|---|---|
| Selenium Identification | Window Handle | Window Handle |
| Switching API | switchTo().window() | switchTo().window() |
| Selenium 4 Creation | WindowType.TAB | WindowType.WINDOW |
| Can contain web elements | Yes | Yes |
| Requires switching when not active | Yes | Yes |
| Windows/Tabs | Frames/iFrames |
|---|---|
| Separate browser contexts | Embedded browsing contexts inside a page |
| Use window handles | Use frame switching |
| switchTo().window() | switchTo().frame() |
| Return using a window handle | Use parentFrame() or defaultContent() |
| Windows/Tabs | Alerts |
|---|---|
| Have window handles | Handled through Alert API |
| Use switchTo().window() | Use switchTo().alert() |
| Contain web pages | Browser dialog |
| Can contain normal web elements | Handled using alert methods |
A new browser context may not appear immediately after clicking a link or button. If Selenium tries to retrieve the handles too quickly, the newly opened context may not yet be available.
Use an explicit wait:
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(d -> d.getWindowHandles().size() > 1);
import java.time.Duration;
import java.util.Set;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
public class WindowWaitExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
String parentWindow = driver.getWindowHandle();
driver.findElement(By.id("openWindow")).click();
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(d ->
d.getWindowHandles().size() > 1);
Set<String> windows = driver.getWindowHandles();
for (String window : windows) {
if (!window.equals(parentWindow)) {
driver.switchTo().window(window);
System.out.println(
driver.getTitle());
break;
}
}
driver.switchTo().window(parentWindow);
driver.quit();
}
}
A common beginner approach is to use:
Thread.sleep(5000);This introduces a fixed delay. If the new tab opens quickly, the test unnecessarily waits. If the application takes longer than the fixed duration, the test may still fail.
Instead, wait for a meaningful condition:
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(d ->
d.getWindowHandles().size() > 1);
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(d ->
d.getWindowHandles().size() == 2);
This waits until exactly two browser contexts are available.
A robust technique is to capture the existing handles before the action and compare them with the handles after the new window appears.
Set<String> oldWindows =
driver.getWindowHandles();
driver.findElement(By.id("openWindow")).click();
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(d ->
d.getWindowHandles().size() > oldWindows.size());
Set<String> newWindows =
driver.getWindowHandles();
newWindows.removeAll(oldWindows);
String newWindow =
newWindows.iterator().next();
driver.switchTo().window(newWindow);
Suppose the application opens several additional browser contexts.
Main Window
|
|-- Child Window 1
|
|-- Child Window 2
|
|-- Child Window 3
All handles can be inspected:
for (String handle : driver.getWindowHandles()) {
driver.switchTo().window(handle);
System.out.println(
"Title: " + driver.getTitle());
System.out.println(
"URL: " + driver.getCurrentUrl());
}
String parentWindow =
driver.getWindowHandle();
for (String handle :
driver.getWindowHandles()) {
driver.switchTo().window(handle);
if (driver.getTitle()
.contains("Payment")) {
System.out.println(
"Payment Window Found");
break;
}
}
driver.switchTo().window(parentWindow);
String parentWindow =
driver.getWindowHandle();
for (String handle :
driver.getWindowHandles()) {
driver.switchTo().window(handle);
if (driver.getCurrentUrl()
.contains("checkout")) {
System.out.println(
"Checkout Window Found");
break;
}
}
driver.switchTo().window(parentWindow);
String parentWindow =
driver.getWindowHandle();
for (String handle :
driver.getWindowHandles()) {
driver.switchTo().window(handle);
if (!driver.findElements(
By.id("checkoutForm")).isEmpty()) {
System.out.println(
"Checkout Page Found");
break;
}
}
driver.switchTo().window(parentWindow);
The close() method closes the currently selected browser tab or window.
driver.close();After closing a browser context, explicitly switch to another valid context.
driver.close();
driver.switchTo().window(parentWindow);
| Method | Purpose |
|---|---|
| close() | Closes the currently selected browser window or tab |
| quit() | Closes all browser windows and ends the WebDriver session |
driver.close();driver.quit();Consider this sequence:
driver.switchTo().window(childWindow);
driver.close();
driver.switchTo().window(parentWindow);
This ensures that Selenium continues with a valid browser context instead of attempting further actions on a closed window.
A web page may contain a link with target="_blank":
<a href="https://example.com" target="_blank">
Open Example
</a>
When the browser opens the link in another tab or window, Selenium can discover the additional context through window handles.
String parentWindow =
driver.getWindowHandle();
driver.findElement(
By.id("supportLink")).click();
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10));
wait.until(d ->
d.getWindowHandles().size() > 1);
for (String handle :
driver.getWindowHandles()) {
if (!handle.equals(parentWindow)) {
driver.switchTo().window(handle);
System.out.println(
"Support Page: " +
driver.getTitle());
break;
}
}
driver.switchTo().window(parentWindow);
String parentWindow =
driver.getWindowHandle();
driver.findElement(
By.linkText("Terms and Conditions"))
.click();
new WebDriverWait(
driver,
Duration.ofSeconds(10))
.until(d ->
d.getWindowHandles().size() > 1);
for (String handle :
driver.getWindowHandles()) {
driver.switchTo().window(handle);
if (driver.getTitle()
.contains("Terms")) {
System.out.println(
"Terms Page Opened");
break;
}
}
driver.close();
driver.switchTo().window(parentWindow);
String mainWindow =
driver.getWindowHandle();
driver.findElement(
By.id("generateReport")).click();
new WebDriverWait(
driver,
Duration.ofSeconds(10))
.until(d ->
d.getWindowHandles().size() > 1);
for (String handle :
driver.getWindowHandles()) {
driver.switchTo().window(handle);
if (driver.getCurrentUrl()
.contains("report")) {
System.out.println(
"Report Window Found");
break;
}
}
driver.switchTo().window(mainWindow);
Some test environments may use an external authentication page in another tab or window. The automation should switch to the required test context, perform authorized test actions, and then return to the main application.
String mainWindow =
driver.getWindowHandle();
driver.findElement(
By.id("externalLogin")).click();
new WebDriverWait(
driver,
Duration.ofSeconds(10))
.until(d ->
d.getWindowHandles().size() > 1);
for (String handle :
driver.getWindowHandles()) {
driver.switchTo().window(handle);
if (driver.getCurrentUrl()
.contains("test-auth")) {
System.out.println(
"Authentication Window Found");
break;
}
}
driver.switchTo().window(mainWindow);
Window handles should not normally be hard-coded because they are generated dynamically for the WebDriver session.
Prefer:
String parent =
driver.getWindowHandle();
Set<String> handles =
driver.getWindowHandles();
Then identify the required handle using reliable application information.
int windowCount =
driver.getWindowHandles().size();
System.out.println(
"Open Windows/Tabs: " +
windowCount);
This is useful for synchronization, validation, and debugging.
int initialCount =
driver.getWindowHandles().size();
driver.findElement(
By.id("openWindow")).click();
new WebDriverWait(
driver,
Duration.ofSeconds(10))
.until(d ->
d.getWindowHandles().size()
> initialCount);
System.out.println(
"New Window Opened");
for (String handle :
driver.getWindowHandles()) {
driver.switchTo().window(handle);
System.out.println(
"Handle: " + handle);
System.out.println(
"Title: " + driver.getTitle());
System.out.println(
"URL: " + driver.getCurrentUrl());
System.out.println(
"----------------------");
}
In a large Selenium automation framework, repeated window-switching code can be placed inside a utility class.
import java.time.Duration;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
public class WindowUtils {
public static void waitForNewWindow(
WebDriver driver,
int expectedCount) {
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10));
wait.until(d ->
d.getWindowHandles().size()
>= expectedCount);
}
public static void switchToWindowByTitle(
WebDriver driver,
String expectedTitle) {
for (String handle :
driver.getWindowHandles()) {
driver.switchTo().window(handle);
if (driver.getTitle()
.contains(expectedTitle)) {
return;
}
}
throw new RuntimeException(
"Window not found: "
+ expectedTitle);
}
public static void switchToWindowByUrl(
WebDriver driver,
String expectedUrl) {
for (String handle :
driver.getWindowHandles()) {
driver.switchTo().window(handle);
if (driver.getCurrentUrl()
.contains(expectedUrl)) {
return;
}
}
throw new RuntimeException(
"Window not found: "
+ expectedUrl);
}
}
String parentWindow =
driver.getWindowHandle();
driver.findElement(
By.id("openReport")).click();
WindowUtils.waitForNewWindow(
driver, 2);
WindowUtils.switchToWindowByTitle(
driver, "Report");
System.out.println(
driver.getTitle());
driver.switchTo().window(
parentWindow);
In the Page Object Model, application-specific actions can be kept inside page classes while reusable window operations can be placed in utility classes.
public class HomePage {
private WebDriver driver;
public HomePage(WebDriver driver) {
this.driver = driver;
}
public void openHelpPage() {
driver.findElement(
By.id("help")).click();
}
public String getCurrentWindow() {
return driver.getWindowHandle();
}
}
import java.time.Duration;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class WindowTest {
WebDriver driver;
@BeforeMethod
public void setup() {
driver = new ChromeDriver();
driver.manage()
.window()
.maximize();
}
@Test
public void verifyNewWindow() {
driver.get("https://example.com");
String parentWindow =
driver.getWindowHandle();
// Action that opens a new tab/window
new WebDriverWait(
driver,
Duration.ofSeconds(10))
.until(d ->
d.getWindowHandles().size() > 1);
for (String handle :
driver.getWindowHandles()) {
if (!handle.equals(parentWindow)) {
driver.switchTo()
.window(handle);
Assert.assertFalse(
driver.getTitle().isEmpty());
break;
}
}
}
@AfterMethod
public void tearDown() {
if (driver != null) {
driver.quit();
}
}
}
| Exception | Possible Cause |
|---|---|
| NoSuchWindowException | Trying to use a window that has been closed or is unavailable |
| TimeoutException | Expected window did not appear within the wait period |
| NoSuchElementException | Element is not present in the currently selected page |
| StaleElementReferenceException | Previously located element is no longer valid after a context/page change |
NoSuchWindowException can occur when Selenium attempts to interact with a browser context that no longer exists.
driver.switchTo().window(childWindow);
driver.close();
// The child window is already closed
// Further interaction with it can fail
After closing the child, switch to a remaining valid context.
A timeout can occur if a new tab or window does not become available within the configured wait period.
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10));
wait.until(d ->
d.getWindowHandles().size() > 1);
A common error is clicking a link that opens another tab and then immediately searching for an element from that tab without switching.
Incorrect:
driver.findElement(
By.id("openTab")).click();
driver.findElement(
By.id("childElement")).click();
Correct:
String parent =
driver.getWindowHandle();
driver.findElement(
By.id("openTab")).click();
new WebDriverWait(
driver,
Duration.ofSeconds(10))
.until(d ->
d.getWindowHandles().size() > 1);
for (String handle :
driver.getWindowHandles()) {
if (!handle.equals(parent)) {
driver.switchTo()
.window(handle);
break;
}
}
driver.findElement(
By.id("childElement")).click();
Always store the original handle before opening another tab or window.
String parentWindow =
driver.getWindowHandle();
Without storing it, returning to the original page becomes less straightforward when several windows are present.
Do not depend on a fixed string as a window handle.
Incorrect:
driver.switchTo()
.window("hard-coded-window");
Correct:
Set<String> handles =
driver.getWindowHandles();
for (String handle : handles) {
driver.switchTo().window(handle);
// Identify required window
}
For simple examples, an Iterator can be convenient, but robust automation should not depend on an assumed order of handles.
Instead of blindly assuming that the second handle is the required window, identify it using:
If the application opens the new tab asynchronously, Selenium may collect the handles before the new context is available.
Use:
new WebDriverWait(
driver,
Duration.ofSeconds(10))
.until(d ->
d.getWindowHandles().size() > 1);
Before calling close(), verify which browser context is currently active.
System.out.println(
"Current Title: " +
driver.getTitle());
System.out.println(
"Current URL: " +
driver.getCurrentUrl());
This is especially useful when several tabs are open.
Start Test
|
v
Open Application
|
v
Store Parent Handle
|
v
Click Link / Button
|
v
New Tab / Window Opens
|
v
Wait for New Handle
|
v
Get All Handles
|
v
Identify Required Handle
|
v
Switch to Required Window
|
v
Perform Test Actions
|
v
Validate Page
|
v
Close Child if Required
|
v
Switch to Parent
|
v
Continue Test
|
v
Quit Browser
| Application Area | Example |
|---|---|
| Reports | Report opens in a new tab |
| Documentation | Documentation opens in another tab |
| Support | Support portal opens separately |
| Authentication | Authentication page opens in another browser context |
| External Services | External test service opens separately |
| Terms and Conditions | Legal information opens in a new tab |
| Product Comparison | Comparison page opens separately |
| Preview | Preview page opens in another tab |
Create a Selenium automation project in which the main application contains links for Documentation, Support, and Company Information. Each link opens a new browser tab.
Main Application
|
+-- Documentation
| |
| +-- New Tab
| +-- Validate
| +-- Close
|
+-- Support
| |
| +-- New Tab
| +-- Validate
| +-- Close
|
+-- Company
|
+-- New Tab
+-- Validate
+-- Close
|
v
Main Application
import java.time.Duration;
import java.util.Set;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
public class MultiTabTest {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage()
.window()
.maximize();
driver.get("https://example.com");
String parentWindow =
driver.getWindowHandle();
driver.findElement(
By.id("documentation")).click();
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10));
wait.until(d ->
d.getWindowHandles().size() > 1);
Set<String> handles =
driver.getWindowHandles();
for (String handle : handles) {
if (!handle.equals(parentWindow)) {
driver.switchTo()
.window(handle);
System.out.println(
"Child Title: " +
driver.getTitle());
System.out.println(
"Child URL: " +
driver.getCurrentUrl());
driver.close();
break;
}
}
driver.switchTo()
.window(parentWindow);
System.out.println(
"Parent Title: " +
driver.getTitle());
driver.quit();
}
}
A scalable automation framework can separate page-specific actions, window utilities, and test validation.
Test Class
|
+-- Page Objects
|
+-- Window Utility
|
+-- Wait Utility
|
+-- Test Data
|
+-- Assertions
|
v
Browser Automation
A window handle is a unique identifier used by Selenium WebDriver to identify a browser window or tab.
driver.getWindowHandle();driver.getWindowHandles();driver.switchTo().window(handle);driver.switchTo().window(parentWindow);close() closes the currently selected browser context, while quit() closes all browser contexts and ends the WebDriver session.
Retrieve all window handles, iterate through them, identify the required browser context using title, URL, or another reliable condition, and switch using switchTo().window().
Yes. Selenium WebDriver handles both through window handles.
new WebDriverWait(
driver,
Duration.ofSeconds(10))
.until(d ->
d.getWindowHandles().size() > 1);
driver.switchTo()
.newWindow(WindowType.TAB);
Store the required parent handle, retrieve all handles, switch through the available contexts, and identify the required one using a reliable property such as its title, URL, or unique page element.
Window handles are dynamically generated for the current WebDriver session and should therefore be retrieved at runtime.
The closed browser context can no longer be used. The test should switch to another valid remaining window before continuing.
Capture the number or set of handles before the action, perform the action, and wait until the number of available handles increases.
Use getWindowHandles() dynamically and iterate through all available contexts while identifying the required page using application-specific information.
| Task | Selenium Code |
|---|---|
| Get current window | driver.getWindowHandle() |
| Get all windows | driver.getWindowHandles() |
| Switch window | driver.switchTo().window(handle) |
| Create new tab | driver.switchTo().newWindow(WindowType.TAB) |
| Create new window | driver.switchTo().newWindow(WindowType.WINDOW) |
| Close current tab/window | driver.close() |
| Close entire browser session | driver.quit() |
| Get current title | driver.getTitle() |
| Get current URL | driver.getCurrentUrl() |
| Wait for additional context | wait.until(d -> d.getWindowHandles().size() > 1) |
Create a Selenium test that performs the following workflow:
Question: How do you handle multiple windows or tabs in Selenium?
Answer: Selenium handles browser windows and tabs using unique window handles. First, I store the current window handle using getWindowHandle(). Then I perform the action that opens the new tab or window and wait until the additional browser context becomes available. I retrieve all handles using getWindowHandles(), identify the required window using its title, URL, or another reliable condition, and switch to it using driver.switchTo().window(handle). After completing the required actions, I can close the child window if required and switch back to the parent window using its stored handle. In Selenium 4, I can also create a new tab or window using newWindow(WindowType.TAB) or newWindow(WindowType.WINDOW).
Windows and Tabs handling is an essential part of Selenium WebDriver automation. Whenever a web application opens another browser tab or window, Selenium must identify and switch to the corresponding window handle before interacting with elements in that context.
The basic workflow is to save the parent handle, perform the action that opens a new context, wait for the new handle, retrieve all handles, identify the required window, switch using switchTo().window(), perform the required validation or interaction, and finally return to the parent window.
For reliable automation, avoid hard-coded handles and unnecessary fixed delays. Use explicit waits, title/URL validation, reusable window utilities, Page Object Model practices, and proper browser-session cleanup.
Learn Windows and Tabs together with Selenium WebDriver, Java, TestNG, locators, waits, frames, alerts, advanced browser interactions, automation frameworks, and real-world testing projects:
Current Browser Context
|
v
driver.getWindowHandle()
|
v
Store Parent Handle
|
v
Open New Tab / Window
|
v
Wait for New Context
|
v
driver.getWindowHandles()
|
v
Identify Required Handle
|
v
driver.switchTo().window(handle)
|
v
Perform Actions
|
v
driver.close() if required
|
v
driver.switchTo().window(parentHandle)
|
v
Continue Test
|
v
driver.quit()
